/* istanbul ignore file */
/* tslint:disable */
/* eslint-disable */
import type { config } from '../models/config';
import { request as __request, checkJsonSchema as __checkJsonSchema } from '../../core/request';
const schemas = require("../schema").default;

export class TestTaskManagementService {

    /**
     * 创建一个测试任务
     * @returns any Example response
     * @throws ApiError
     */
    public static async addTask({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 产品版本ID
             */
            productVId: number,
            /**
             * 测试方案ID
             */
            planId: number,
            /**
             * 用例名称
             */
            policy: {
                /**
                 * 策略类型，可取值：
                 * now – 立即执行
                 * delay – 延迟执行
                 * cycle – 周期执行
                 */
                type: string,
                /**
                 * 延迟时间，单位：min，仅当type=delay时有效
                 */
                delay?: number,
                /**
                 * 执行次数，仅当type=cycle时有效
                 */
                count?: number,
                /**
                 * 周期类型，仅当type=cycle时有效，可取值：
                 * everyday - 每天，everyhour - 每小时
                 */
                cycle?: string,
                /**
                 * 周期执行的时间点，仅当type=cycle时有效，
                 * 示例：12:30
                 */
                timepoint?: string,
            },
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'POST',
            path: `/taskmanager/v1/add-task`,
            body: requestBody,
        });

        __checkJsonSchema("addTask", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 查看测试任务详情
     * @returns any OK
     * @throws ApiError
     */
    public static async getTaskDetail({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 测试任务ID
             */
            taskId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 测试任务基本信息
         */
        baseInfo: {
            /**
             * 产品名称
             */
            productName: string,
            /**
             * 产品版本号
             */
            productVersion: string,
            /**
             * 测试方案名称
             */
            planName: string,
            /**
             * 状态，可取值：
             * running – 正在执行
             * waiting – 等待执行
             * runover – 已执行
             * terminated – 已终止
             */
            status: string,
            /**
             * 运行人员名称
             */
            operatorName: string,
            /**
             * 发起方式，可取值：web、jenkins
             */
            launchFrom: string,
            /**
             * 任务开始时间
             */
            startTime: string,
            /**
             * 任务结束时间
             */
            endTime: string,
            /**
             * 运行时长
             */
            duration: string,
        },
        /**
         * 目标配置
         */
        targetConfig: Array<config>,
        /**
         * 环境配置
         */
        envConfig: Array<config>,
        /**
         * 压力配置
         */
        stressConfig?: Array<config>,
        /**
         * 自定义配置
         */
        selfConfig?: Array<config>,
        /**
         * 执行策略
         */
        policy: {
            /**
             * 策略类型，可取值：
             * now – 立即执行
             * delay – 延迟执行
             * cycle – 周期执行
             */
            type: string,
            /**
             * 延迟时间，单位：min，仅当type=delay时有效
             */
            delay?: number,
            /**
             * 执行次数，仅当type=cycle时有效
             */
            count?: number,
            /**
             * 周期类型，仅当type=cycle时有效，可取值：
             * everyday - 每天，everyhour - 每小时
             */
            cycle?: string,
            /**
             * 周期执行的时间点，仅当type=cycle时有效，
             * 示例：12:30
             */
            timepoint?: string,
        },
        /**
         * 任务中的测试用例执行结果列表
         */
        caseResults?: Array<{
            /**
             * 测试用例ID，对应MySQL主键
             */
            caseId: number,
            /**
             * 测试状态，可取值：
             * running – 正在测试
             * waiting – 等待测试
             * runover – 已测试
             */
            status: string,
            /**
             * 成功率
             */
            successRate?: number,
            /**
             * 用例测试结果，可取值：OK、NOK
             */
            result?: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/taskmanager/v1/get-task`,
            body: requestBody,
        });

        __checkJsonSchema("getTaskDetail", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 列举当前运行的测试任务列表，即等待执行和正在执行的任务
     * @returns any OK
     * @throws ApiError
     */
    public static async getListOntasks({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 测试产品ID
             */
            productId?: number,
            /**
             * 测试方案ID
             */
            planId?: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount: number,
        /**
         * 任务列表
         */
        tasks: Array<{
            /**
             * 任务ID，对应Mongo主键
             */
            id: string,
            /**
             * 产品名称
             */
            productName: string,
            /**
             * 产品版本号
             */
            productVersion: string,
            /**
             * 方案名称
             */
            planName: string,
            /**
             * 运行人
             */
            operatorName: string,
            /**
             * 发起方式
             */
            launchFrom: string,
            /**
             * 发起时间
             */
            startTime: string,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/taskmanager/v1/list-ontasks`,
            body: requestBody,
        });

        __checkJsonSchema("getListOntasks", schemas, result);
        return result.body;
    }

    /**
     * Your GET endpoint
     * 列举历史测试任务列表，即已执行和已终止的任务
     * @returns any OK
     * @throws ApiError
     */
    public static async getListOvertasks({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 测试方案ID
             */
            planId?: number,
            /**
             * 分页查询的页数
             * 1）不传该参数，查询内容不分页
             * 2）传大于等于1的整数时，分页查询
             */
            pageNum?: number,
            /**
             * 分页查询的每页数据条数，取值范围 1-100。默认提取20条
             */
            pageDataCount?: number,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
        /**
         * 总记录数
         */
        totalDataCount: number,
        /**
         * 任务列表
         */
        tasks: Array<{
            /**
             * 任务ID，对应Mongo主键
             */
            id: string,
            /**
             * 运行人
             */
            operatorName: string,
            /**
             * 发起方式
             */
            launchFrom: string,
            /**
             * 发起时间
             */
            startTime: string,
            /**
             * 结束时间
             */
            endTime: string,
            /**
             * 运行时长
             */
            duration: string,
            /**
             * 通过率
             */
            passRate: number,
        }>,
    }> {
        const result = await __request({
            method: 'GET',
            path: `/taskmanager/v1/list-overtasks`,
            body: requestBody,
        });

        __checkJsonSchema("getListOvertasks", schemas, result);
        return result.body;
    }

    /**
     * 终止一个测试任务
     * @returns any Example response
     * @throws ApiError
     */
    public static async stopTeatTask({
        requestBody,
    }: {
        requestBody?: {
            /**
             * 任务ID
             */
            taskId: string,
        },
    }): Promise<{
        /**
         * 值为0，操作成功
         */
        optResult: number,
        /**
         * 操作失败说明
         */
        msg?: string,
    }> {
        const result = await __request({
            method: 'PUT',
            path: `/taskmanager/v1/stop-task`,
            body: requestBody,
        });

        __checkJsonSchema("stopTeatTask", schemas, result);
        return result.body;
    }

}